package com.wink_172.library.utils;

import android.content.Context;
import android.media.AudioManager;
import android.media.SoundPool;
import android.os.Build;
import android.util.Log;

import java.util.HashMap;

/**
 * 本地提示音播放器
 * SoundPool用于播放声音短，文件小的音频，延时短
 *
 * @author: heiyulong
 * @date: 2021/4/16
 * 准备的音频文放入assets文件夹下或者res下的raw文件夹下：
 * <p>
 * assets下可以再新建文件夹批量加载，而raw只能同级存放单个加载；
 * 在assets内部单个文件超过1m时可能存在bug，在raw资源目录下不会存在；
 * SoundPool的音频文件大小不能超过1M同时时间超过5-6秒可能会出错。
 * ————————————————
 * 想要同时播放多少个音效 就创建多少个对象SoundPlayerUtil
 * <p>
 * 版权声明：本文为CSDN博主「涂程」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
 * 原文链接：https://blog.csdn.net/u012165769/article/details/116458422
 */
public class SoundPlayerUtil {
    private static final String TAG = "SoundPlayer";
    private static final int MAX_SOUNDS = 5;
    private Context appContext;

    public SoundPool getSoundPool() {
        return soundPool;
    }

    private SoundPool soundPool;
    private HashMap<Integer, Integer> soundMap = new HashMap<>();

    public SoundPlayerUtil(Context appContext) {
        // 版本兼容
        this.appContext = appContext;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            soundPool = new SoundPool.Builder().setMaxStreams(MAX_SOUNDS).build();
        } else {
            //第一个参数是可以支持的声音数量，第二个是声音类型，第三个是声音品质
            soundPool = new SoundPool(MAX_SOUNDS, AudioManager.STREAM_MUSIC, 0);
        }
    }

    /**
     * 播放音频
     *
     * @param resId      音频文件 R.raw.xxx
     * @param repeatTime 循环模式：0表示循环一次，-1表示一直循环，其他表示数字+1表示当前数字对应的循环次
     */
    public void play(int resId, int repeatTime) {
        int soundID = soundPool.load(appContext, resId, 1);
        // 该方法防止sample not ready错误
        soundPool.setOnLoadCompleteListener((soundPool, sampleId, status) -> {
            int streamId = soundPool.play(
                    soundID,  //声音id
                    1, //左声道：0.0f ~ 1.0f
                    1, //右声道：0.0f ~ 1.0f
                    1, //播放优先级：0表示最低优先级
                    repeatTime, //循环模式：0表示循环一次，-1表示一直循环，其他表示数字+1表示当前数字对应的循环次
                    1);//播放速度：1是正常，范围从0~2
            soundMap.put(resId, streamId);
        });
    }


    /**
     * 播放音频
     *
     * @param resId 音频文件 R.raw.xxx
     */
    public void play2(int resId) {
        int soundID = soundPool.load(appContext, resId, 1);
//        Log.e(TAG, "play: ====>>01:"+soundID );
        // 该方法防止sample not ready错误

        float volume=1.0f;//Utils.INSTANCE.randFloatBetween(0.3f, 1.0f);//音量大小随机
        soundPool.setOnLoadCompleteListener((soundPool, sampleId, status) -> {
            int streamId = soundPool.play(
                    soundID,  //声音id
                    volume, //左声道：0.0f ~ 1.0f
                    volume, //右声道：0.0f ~ 1.0f
                    1, //播放优先级：0表示最低优先级
                    0, //循环模式：0表示循环一次，-1表示一直循环，其他表示数字+1表示当前数字对应的循环次
                    1);//播放速度：1是正常，范围从0~2
            soundMap.put(resId, streamId);
        });
//        Log.e(TAG, "play: ====>>02:" );
    }
//
    /**
     * 播放音频
     *
     * @param soundID
     */
    public void play3(int resId,int soundID) {
//        int soundID = soundPool.load(appContext, resId, 1);
//        Log.e(TAG, "play: ====>>01:"+soundID );
        // 该方法防止sample not ready错误

//        float volume=1.0f;//Utils.INSTANCE.randFloatBetween(0.3f, 1.0f);//音量大小随机
//        soundPool.setOnLoadCompleteListener((soundPool, sampleId, status) -> {
//            int streamId = soundPool.play(
//                    soundID,  //声音id
//                    volume, //左声道：0.0f ~ 1.0f
//                    volume, //右声道：0.0f ~ 1.0f
//                    1, //播放优先级：0表示最低优先级
//                    0, //循环模式：0表示循环一次，-1表示一直循环，其他表示数字+1表示当前数字对应的循环次
//                    1);//播放速度：1是正常，范围从0~2
//            soundMap.put(resId, streamId);
//        });
//        Log.e(TAG, "play: ====>>02:" );
    }

    float volume_new=0;
    /**
     * 播放音频
     *
     * @param resId 音频文件 R.raw.xxx
     */
    public void play(int resId) {
        int soundID = soundPool.load(appContext, resId, 1);
//        Log.e(TAG, "play: ====>>01:"+soundID );
        // 该方法防止sample not ready错误

//        float volume=Utils.INSTANCE.randFloatBetween(0f, 1.0f);//音量大小随机
//
//        if(volume>0.33){
//            volume_new=0.2f;
//        }else {
            volume_new=1f;
//        }
        soundPool.setOnLoadCompleteListener((soundPool, sampleId, status) -> {
            int streamId = soundPool.play(
                    soundID,  //声音id
                    volume_new, //左声道：0.0f ~ 1.0f
                    volume_new, //右声道：0.0f ~ 1.0f
                    1, //播放优先级：0表示最低优先级
                    0, //循环模式：0表示循环一次，-1表示一直循环，其他表示数字+1表示当前数字对应的循环次
                    1);//播放速度：1是正常，范围从0~2
            soundMap.put(resId, streamId);
        });
//        Log.e(TAG, "play: ====>>02:" );
    }


    /**
     * 暂停
     *
     * @param resId
     */
    public void pause(int resId) {
        if (soundPool != null) {
            Integer mStreamID = soundMap.get(resId);
            if (mStreamID != null) {
                soundPool.pause(mStreamID);
            }
        }
    }

    /**
     * 继续
     *
     * @param resId
     */
    public void resume(int resId) {
        if (soundPool != null) {
            Integer mStreamID = soundMap.get(resId);
            if (mStreamID != null) {
                soundPool.resume(mStreamID);
            }
        }
    }

    /**
     * 停止
     *
     * @param resId
     */
    public void stop(int resId) {
        if (soundPool != null) {
            Integer mStreamID = soundMap.get(resId);
            if (mStreamID != null) {
                soundPool.stop(mStreamID);
            }
        }
    }

    /**
     * 资源释放
     */
    public void release() {
        Log.d(TAG, "Cleaning resources..");
        if (soundPool != null) {
            soundPool.autoPause();
            soundPool.release();
        }
    }


}
